diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 69e4614..5282c20 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -77,6 +77,7 @@
     <li>Documented the timezones() function in the <a href="./helpers/date_helper.html">Date Helper</a>.</li>
     <li>Documented unset_userdata in the <a href="./libraries/sessions.html">Session class</a>.</li>
     <li>Changed the behaviour of custom callbacks so that they no longer trigger the &quot;required&quot; rule. </li>
+    <li>Added a few additional mime type variations for CSV </li>
     <li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where valid_ip() wasn't called properly.</li>
     <li>Fixed a bug in the Session library where user agent matching would fail on user agents ending with a space. </li>
     <li>Fixed a bug in database driver where num_rows property wasn't getting updated.</li>
